// Base64Encoder.java
// $Id: Base64Encoder.java,v 1.2 2003/12/04 15:27:03 rsegelman Exp $
// (c) COPYRIGHT MIT and INRIA, 1996.
// Please first read the full copyright statement in file COPYRIGHT.html
package com.ossez.usreio.common.util;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;


/**
 * BASE64 encoder implementation.
 * This object takes as parameter an input stream and an output stream. It
 * encodes the input stream, using the BASE64 encoding rules, as defined
 * in <a href="http://ds.internic.net/rfc/rfc1521.txt">MIME specification</a>
 * and emit the resulting data to the output stream.
 */
public class Base64Encoder {
    private static final int BUFFER_SIZE = 1024;
    private static byte[] encoding = {
        (byte) 'A', (byte) 'B', (byte) 'C', (byte) 'D', (byte) 'E', (byte) 'F',
        (byte) 'G', (byte) 'H', // 0-7
        (byte) 'I', (byte) 'J', (byte) 'K', (byte) 'L', (byte) 'M', (byte) 'N',
        (byte) 'O', (byte) 'P', // 8-15
        (byte) 'Q', (byte) 'R', (byte) 'S', (byte) 'T', (byte) 'U', (byte) 'V',
        (byte) 'W', (byte) 'X', // 16-23
        (byte) 'Y', (byte) 'Z', (byte) 'a', (byte) 'b', (byte) 'c', (byte) 'd',
        (byte) 'e', (byte) 'f', // 24-31
        (byte) 'g', (byte) 'h', (byte) 'i', (byte) 'j', (byte) 'k', (byte) 'l',
        (byte) 'm', (byte) 'n', // 32-39
        (byte) 'o', (byte) 'p', (byte) 'q', (byte) 'r', (byte) 's', (byte) 't',
        (byte) 'u', (byte) 'v', // 40-47
        (byte) 'w', (byte) 'x', (byte) 'y', (byte) 'z', (byte) '0', (byte) '1',
        (byte) '2', (byte) '3', // 48-55
        (byte) '4', (byte) '5', (byte) '6', (byte) '7', (byte) '8', (byte) '9',
        (byte) '+', (byte) '/', // 56-63
        (byte) '=' // 64
    };
    InputStream in = null;
    OutputStream out = null;
    boolean stringp = false;

    /**
     * Create a new Base64 encoder, to encode the given string.
     * @param input The String to be encoded.
     */
    public Base64Encoder(String input) {
        byte[] bytes = new byte[input.length()];
        input.getBytes(0, bytes.length, bytes, 0);
        this.stringp = true;
        this.in = new ByteArrayInputStream(bytes);
        this.out = new ByteArrayOutputStream();
    }

    /**
     * Create a new Base64 encoder, encoding input to output.
     * @param in The input stream to be encoded.
     * @param out The output stream, to write encoded data to.
     */
    public Base64Encoder(InputStream in, OutputStream out) {
        this.in = in;
        this.out = out;
        this.stringp = false;
    }

    private final int get1(byte[] buf, int off) {
        return (buf[off] & 0xfc) >> 2;
    }

    private final int get2(byte[] buf, int off) {
        return ((buf[off] & 0x3) << 4) | ((buf[off + 1] & 0xf0) >>> 4);
    }

    private final int get3(byte[] buf, int off) {
        return ((buf[off + 1] & 0x0f) << 2) | ((buf[off + 2] & 0xc0) >>> 6);
    }

    private static final int get4(byte[] buf, int off) {
        return buf[off + 2] & 0x3f;
    }

    /**
     * Process the data: encode the input stream to the output stream.
     * This method runs through the input stream, encoding it to the output
     * stream.
     * @exception IOException If we weren't able to access the input stream or
     *    the output stream.
     */
    public void process() throws IOException {
        byte[] buffer = new byte[BUFFER_SIZE];
        int got = -1;
        int off = 0;
        int count = 0;

        while ((got = in.read(buffer, off, BUFFER_SIZE - off)) > 0) {
            if (got >= 3) {
                got += off;
                off = 0;

                while ((off + 3) <= got) {
                    int c1 = get1(buffer, off);
                    int c2 = get2(buffer, off);
                    int c3 = get3(buffer, off);
                    int c4 = get4(buffer, off);

                    switch (count) {
                    case 73:
                        out.write(encoding[c1]);
                        out.write(encoding[c2]);
                        out.write(encoding[c3]);
                        out.write('\n');
                        out.write(encoding[c4]);
                        count = 1;

                        break;

                    case 74:
                        out.write(encoding[c1]);
                        out.write(encoding[c2]);
                        out.write('\n');
                        out.write(encoding[c3]);
                        out.write(encoding[c4]);
                        count = 2;

                        break;

                    case 75:
                        out.write(encoding[c1]);
                        out.write('\n');
                        out.write(encoding[c2]);
                        out.write(encoding[c3]);
                        out.write(encoding[c4]);
                        count = 3;

                        break;

                    case 76:
                        out.write('\n');
                        out.write(encoding[c1]);
                        out.write(encoding[c2]);
                        out.write(encoding[c3]);
                        out.write(encoding[c4]);
                        count = 4;

                        break;

                    default:
                        out.write(encoding[c1]);
                        out.write(encoding[c2]);
                        out.write(encoding[c3]);
                        out.write(encoding[c4]);
                        count += 4;

                        break;
                    }

                    off += 3;
                }

                // Copy remaining bytes to beginning of buffer:
                for (int i = 0; i < 3; i++)
                    buffer[i] = (i < (got - off)) ? buffer[off + i] : ((byte) 0);

                off = got - off;
            } else {
                // Total read amount is less then 3 bytes:
                off += got;
            }
        }

        // Manage the last bytes, from 0 to off:
        switch (off) {
        case 1:
            out.write(encoding[get1(buffer, 0)]);
            out.write(encoding[get2(buffer, 0)]);
            out.write('=');
            out.write('=');

            break;

        case 2:
            out.write(encoding[get1(buffer, 0)]);
            out.write(encoding[get2(buffer, 0)]);
            out.write(encoding[get3(buffer, 0)]);
            out.write('=');
        }

        return;
    }

    /**
     * Encode the content of this encoder, as a string.
     * This methods encode the String content, that was provided at creation
     * time, following the BASE64 rules, as specified in the rfc1521.
     * @return A String, reprenting the encoded content of the input String.
     */
    public String processString() {
        if (!stringp) {
            throw new RuntimeException(this.getClass().getName() +
                "[processString]" + "invalid call (not a String)");
        }

        try {
            process();
        } catch (IOException e) {
        }

        return ((ByteArrayOutputStream) out).toString();
    }

    /**
     * Testing the encoder.
     * Run with one argument, prints the encoded version of it.
     */
    public static void main(String[] args) {
        if (args.length != 1) {
            System.out.println("Base64Encoder <string>");
            System.exit(0);
        }

        Base64Encoder b = new Base64Encoder(args[0]);
        System.out.println("[" + b.processString() + "]");

        // joe:eoj -> am9lOmVvag==
        // 12345678:87654321 -> MTIzNDU2Nzg6ODc2NTQzMjE=
    }
}
